BCI NET/BCI NET Dec 94.iso/archives/programming/source/tsm23s.lha/SaveHAMetc.c

C/C++ Source or Header | 1993-10-08 | 17KB | 844 lines

// TSMorph - Amiga Morphing program
// Copyright (C) © 1993  Topicsave Limited

// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// any later version.

// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.

// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.

// [e-mail]

//    $Author: M_J_Paddock $
//    $Date: 1992/08/08 01:10:03 $
//    $Revision: 1.1 $

// This is routines to save chunky 24 bit RGB in various formats
// B&W 16 grey scale
// B&W 256 grey scale
// HAM6 with fixed palette (but could easily used variable palette)
// HAM6 with fixed palette (but could easily used variable palette)
// DCTV

// include headers
#include <proto/iffparse.h>
#include <graphics/view.h>
#include <libraries/dctv.h>
#include <clib/dctv_protos.h>
#include <pragmas/dctv_pragmas.h>
extern struct Library *DCTVBase;

// IFF header
#include "iffp/ILBMapp.h"

// Following explains(?) the palette choices

//   0 = x00 = b00000000
//  85 = x55 = b01010101
// 170 = xaa = b10101010
// 255 = xff = b11111111

//   0 = x00 = o000 = b00000000
//  36 = x24 = o111 = b00100100
//  73 = x49 = o222 = b01001001
// 109 = x6d = o333 = b01101101
// 146 = x92 = o444 = b10010010
// 182 = xb6 = o555 = b10110110
// 219 = xdb = o666 = b11011011
// 255 = xff = o777 = b11111111

//   0 = x00 = b00000000
//  17 = x11 = b00010001
//  34 = x22 = b00100010
//  51 = x33 = b00110011
//  68 = x44 = b01000100
//  85 = x55 = b01010101
// 102 = x66 = b01100110
// 119 = x77 = b01110111
// 136 = x88 = b10001000
// 153 = x99 = b10011001
// 170 = xaa = b10101010
// 187 = xbb = b10111011
// 204 = xcc = b11001100
// 221 = xdd = b11011101
// 238 = xee = b11101110
// 255 = xff = b11111111

// 16 grey shade palette
UBYTE BW16_Palette[48] = {
    0,0,0,
    17,17,17,
    34,34,34,
    51,51,51,
    68,68,68,
    85,85,85,
    102,102,102,
    119,119,119,
    136,136,136,
    153,153,153,
    170,170,170,
    187,187,187,
    204,204,204,
    221,221,221,
    238,238,238,
    255,255,255
};

// 256 grey shade palette
UBYTE BW256_Palette[768] = {
    0,0,0,
    1,1,1,
    2,2,2,
    3,3,3,
    4,4,4,
    5,5,5,
    6,6,6,
    7,7,7,
    8,8,8,
    9,9,9,
    10,10,10,
    11,11,11,
    12,12,12,
    13,13,13,
    14,14,14,
    15,15,15,
    16,16,16,
    17,17,17,
    18,18,18,
    19,19,19,
    20,20,20,
    21,21,21,
    22,22,22,
    23,23,23,
    24,24,24,
    25,25,25,
    26,26,26,
    27,27,27,
    28,28,28,
    29,29,29,
    30,30,30,
    31,31,31,
    32,32,32,
    33,33,33,
    34,34,34,
    35,35,35,
    36,36,36,
    37,37,37,
    38,38,38,
    39,39,39,
    40,40,40,
    41,41,41,
    42,42,42,
    43,43,43,
    44,44,44,
    45,45,45,
    46,46,46,
    47,47,47,
    48,48,48,
    49,49,49,
    50,50,50,
    51,51,51,
    52,52,52,
    53,53,53,
    54,54,54,
    55,55,55,
    56,56,56,
    57,57,57,
    58,58,58,
    59,59,59,
    60,60,60,
    61,61,61,
    62,62,62,
    63,63,63,
    64,64,64,
    65,65,65,
    66,66,66,
    67,67,67,
    68,68,68,
    69,69,69,
    70,70,70,
    71,71,71,
    72,72,72,
    73,73,73,
    74,74,74,
    75,75,75,
    76,76,76,
    77,77,77,
    78,78,78,
    79,79,79,
    80,80,80,
    81,81,81,
    82,82,82,
    83,83,83,
    84,84,84,
    85,85,85,
    86,86,86,
    87,87,87,
    88,88,88,
    89,89,89,
    90,90,90,
    91,91,91,
    92,92,92,
    93,93,93,
    94,94,94,
    95,95,95,
    96,96,96,
    97,97,97,
    98,98,98,
    99,99,99,
    100,100,100,
    101,101,101,
    102,102,102,
    103,103,103,
    104,104,104,
    105,105,105,
    106,106,106,
    107,107,107,
    108,108,108,
    109,109,109,
    110,110,110,
    111,111,111,
    112,112,112,
    113,113,113,
    114,114,114,
    115,115,115,
    116,116,116,
    117,117,117,
    118,118,118,
    119,119,119,
    120,120,120,
    121,121,121,
    122,122,122,
    123,123,123,
    124,124,124,
    125,125,125,
    126,126,126,
    127,127,127,
    128,128,128,
    129,129,129,
    130,130,130,
    131,131,131,
    132,132,132,
    133,133,133,
    134,134,134,
    135,135,135,
    136,136,136,
    137,137,137,
    138,138,138,
    139,139,139,
    140,140,140,
    141,141,141,
    142,142,142,
    143,143,143,
    144,144,144,
    145,145,145,
    146,146,146,
    147,147,147,
    148,148,148,
    149,149,149,
    150,150,150,
    151,151,151,
    152,152,152,
    153,153,153,
    154,154,154,
    155,155,155,
    156,156,156,
    157,157,157,
    158,158,158,
    159,159,159,
    160,160,160,
    161,161,161,
    162,162,162,
    163,163,163,
    164,164,164,
    165,165,165,
    166,166,166,
    167,167,167,
    168,168,168,
    169,169,169,
    170,170,170,
    171,171,171,
    172,172,172,
    173,173,173,
    174,174,174,
    175,175,175,
    176,176,176,
    177,177,177,
    178,178,178,
    179,179,179,
    180,180,180,
    181,181,181,
    182,182,182,
    183,183,183,
    184,184,184,
    185,185,185,
    186,186,186,
    187,187,187,
    188,188,188,
    189,189,189,
    190,190,190,
    191,191,191,
    192,192,192,
    193,193,193,
    194,194,194,
    195,195,195,
    196,196,196,
    197,197,197,
    198,198,198,
    199,199,199,
    200,200,200,
    201,201,201,
    202,202,202,
    203,203,203,
    204,204,204,
    205,205,205,
    206,206,206,
    207,207,207,
    208,208,208,
    209,209,209,
    210,210,210,
    211,211,211,
    212,212,212,
    213,213,213,
    214,214,214,
    215,215,215,
    216,216,216,
    217,217,217,
    218,218,218,
    219,219,219,
    220,220,220,
    221,221,221,
    222,222,222,
    223,223,223,
    224,224,224,
    225,225,225,
    226,226,226,
    227,227,227,
    228,228,228,
    229,229,229,
    230,230,230,
    231,231,231,
    232,232,232,
    233,233,233,
    234,234,234,
    235,235,235,
    236,236,236,
    237,237,237,
    238,238,238,
    239,239,239,
    240,240,240,
    241,241,241,
    242,242,242,
    243,243,243,
    244,244,244,
    245,245,245,
    246,246,246,
    247,247,247,
    248,248,248,
    249,249,249,
    250,250,250,
    251,251,251,
    252,252,252,
    253,253,253,
    254,254,254,
    255,255,255,
};

// HAM6 base palette
// note 3 extra entries based on changing r,g or b using HAM stuff
UBYTE HAM6_Palette[57] = {
    0,0,0,
    0,0,170,
    0,85,0,
    0,85,170,
    0,170,0,
    0,170,170,
    0,255,0,
    0,255,170,
    170,0,0,
    170,0,170,
    170,85,0,
    170,85,170,
    170,170,0,
    170,170,170,
    170,255,0,
    170,255,170,
    0,0,0,    // r
    0,0,0,    // g
    0,0,0,    // b
};

// HAM8 base palette
// note 3 extra entries based on changing r,g or b using HAM stuff
UBYTE HAM8_Palette[201] = {
    0,0,0,
    0,0,170,
    0,36,0,
    0,36,170,
    0,73,0,
    0,73,170,
    0,109,0,
    0,109,170,
    0,146,0,
    0,146,170,
    0,182,0,
    0,182,170,
    0,219,0,
    0,219,170,
    0,255,0,
    0,255,170,
    85,0,0,
    85,0,170,
    85,36,0,
    85,36,170,
    85,73,0,
    85,73,170,
    85,109,0,
    85,109,170,
    85,146,0,
    85,146,170,
    85,182,0,
    85,182,170,
    85,219,0,
    85,219,170,
    85,255,0,
    85,255,170,
    170,0,0,
    170,0,170,
    170,36,0,
    170,36,170,
    170,73,0,
    170,73,170,
    170,109,0,
    170,109,170,
    170,146,0,
    170,146,170,
    170,182,0,
    170,182,170,
    170,219,0,
    170,219,170,
    170,255,0,
    170,255,170,
    255,0,0,
    255,0,170,
    255,36,0,
    255,36,170,
    255,73,0,
    255,73,170,
    255,109,0,
    255,109,170,
    255,146,0,
    255,146,170,
    255,182,0,
    255,182,170,
    255,219,0,
    255,219,170,
    255,255,0,
    255,255,170,
    0,0,0,    // r
    0,0,0,    // g
    0,0,0,    // b
};

/* save 16 grey scale
 * FileName : file to save
 * width    : width of image
 * height   : height of image
 * swidth   : widht of image when in full words
 * pwidth   : page width
 * pheight  : page height
 * pmode    : camg chunk
 * red      : red
 * green    : green
 * blue     : blue chunky bit map
 * rp       : a work rast port
 * trp      : another work rast port
 */
BOOL
SaveBW16(UBYTE *FileName,USHORT width,USHORT height, UWORD swidth,
                  USHORT pwidth, USHORT pheight, USHORT pmode,
                  UBYTE *red, UBYTE *green, UBYTE *blue, struct RastPort *rp, struct RastPort *trp) {
    UBYTE *r,*g,*b,*old;
    UWORD x,y;
    BOOL OkFlag;
    struct ILBMInfo *ilbm;
    // allocate IFF stuff
    if (ilbm = (struct ILBMInfo *)AllocMem(sizeof(struct ILBMInfo),MEMF_PUBLIC|MEMF_CLEAR)) {
        if (ilbm->ParseInfo.iff = AllocIFF()) {
            r = red;
            g = green;
            b = blue;
            old = red;
            // for each line
            for (y=0;
                  y<height;
                  y++) {
                // for each column
                for (x=0;
                      x < width;
                      x++) {
                    // convert rgb to 16 grey scale
                    *old++ = ((30 * *r++) + (59 * *g++) + (11 * *b++)) / 1594;
                }
                r += (swidth - width);
                g += (swidth - width);
                b += (swidth - width);
                old += (swidth - width);
            }
            // convert chunky to planar
            WritePixelArray8(rp,0,0,width-1,height-1,red,trp);
            // and save IFF
            OkFlag = !saveilbm(ilbm, rp->BitMap, pmode,
                                     width,  height, pwidth, pheight,
                                     BW16_Palette, 16, 8,    /* colortable */
                                     mskNone, 0,    /* masking, transparent */
                                     NULL, NULL,     /* chunklists */
                                     FileName);
            // Close everything down cleanly
            FreeIFF(ilbm->ParseInfo.iff);
        }
        else {
            OkFlag = FALSE;
        }
        FreeMem(ilbm,sizeof(struct ILBMInfo));
    }
    else {
        OkFlag = FALSE;
    }
    return OkFlag;
}

/* save 256 grey scale
 * see SaveBW16()
 */
BOOL
SaveBW256(UBYTE *FileName,USHORT width,USHORT height, UWORD swidth,
                  USHORT pwidth, USHORT pheight, USHORT pmode,
                  UBYTE *red, UBYTE *green, UBYTE *blue, struct RastPort *rp, struct RastPort *trp) {
    UBYTE *r,*g,*b,*old;
    UWORD x,y;
    BOOL OkFlag;
    struct ILBMInfo *ilbm;
    if (ilbm = (struct ILBMInfo *)AllocMem(sizeof(struct ILBMInfo),MEMF_PUBLIC|MEMF_CLEAR)) {
        if (ilbm->ParseInfo.iff = AllocIFF()) {
            r = red;
            g = green;
            b = blue;
            old = red;
            for (y=0;
                  y<height;
                  y++) {
                for (x=0;
                      x < width;
                      x++) {
                    // convert rgb to 256 grey scale
                    *old = ((30 * *r++) + (59 * *g++) + (11 * *b++)) / 100;
                }
                r += (swidth - width);
                g += (swidth - width);
                b += (swidth - width);
                old += (swidth - width);
            }
            WritePixelArray8(rp,0,0,width-1,height-1,red,trp);
            OkFlag = !saveilbm(ilbm, rp->BitMap, pmode,
                                     width,  height, pwidth, pheight,
                                     BW256_Palette, 256, 8,    /* colortable */
                                     mskNone, 0,    /* masking, transparent */
                                     NULL, NULL,     /* chunklists */
                                     FileName);
            // Close everything down cleanly
            FreeIFF(ilbm->ParseInfo.iff);
        }
        else {
            OkFlag = FALSE;
        }
        FreeMem(ilbm,sizeof(struct ILBMInfo));
    }
    else {
        OkFlag = FALSE;
    }
    return OkFlag;
}

/* save HAM6
 * see SaveBW16()
 */
BOOL
SaveHAM6(UBYTE *FileName,USHORT width,USHORT height, UWORD swidth,
                  USHORT pwidth, USHORT pheight, USHORT pmode,
                  UBYTE *red, UBYTE *green, UBYTE *blue, struct RastPort *rp, struct RastPort *trp) {
    UBYTE *r,*g,*b,*old,*p;
    UWORD x,y;
    ULONG maxdiff;
    ULONG diff;
    LONG t;
    UWORD k;
    UWORD index;
    BOOL OkFlag;
    struct ILBMInfo *ilbm;
    UBYTE lr,lg,lb;
    if (ilbm = (struct ILBMInfo *)AllocMem(sizeof(struct ILBMInfo),MEMF_PUBLIC|MEMF_CLEAR)) {
        if (ilbm->ParseInfo.iff = AllocIFF()) {
            r = red;
            g = green;
            b = blue;
            old = red;
            for (y=0;
                  y<height;
                  y++) {
                lr = 0;
                lg = 0;
                lb = 0;
                for (x=0;
                      x < width;
                      x++) {
                    // colour if we use HAM to change R or G or B
                    HAM6_Palette[16*3] = *r;
                    HAM6_Palette[16*3+1] = lg;
                    HAM6_Palette[16*3+2] = lb;
                    HAM6_Palette[17*3] = lr;
                    HAM6_Palette[17*3+1] = *g;
                    HAM6_Palette[17*3+2] = lb;
                    HAM6_Palette[18*3] = lr;
                    HAM6_Palette[18*3+1] = lg;
                    HAM6_Palette[18*3+2] = *b;
                    // Find closest color
                    maxdiff = 0x7FFFFFFF;
                    p = HAM6_Palette;
                    for (k = 0;
                          k < 19;
                          ++k) {
                        t = *r - *p++;
                        diff = t*t*3;
                        t = *g - *p++;
                        diff += (t*t*6);
                        t = *b - *p++;
                        diff += (t*t);
                        if (diff < maxdiff) {
                            maxdiff = diff;
                            index = k;
                        }
                    }
                    lr = HAM6_Palette[index*3];
                    lg = HAM6_Palette[index*3+1];
                    lb = HAM6_Palette[index*3+2];
                    // Set HAM bits if required
                    if (index == 16) {
                        *old++ = (*r>>4) | 0x20;
                    }
                    else {
                        if (index == 17) {
                            *old++ = (*g>>4) | 0x30;
                        }
                        else {
                            if (index == 18) {
                                *old++ = (*b>>4) | 0x10;
                            }
                            else {
                                *old++ = index;
                            }
                        }
                    }
                    r++;
                    g++;
                    b++;
                }
                r += (swidth - width);
                g += (swidth - width);
                b += (swidth - width);
                old += (swidth - width);
            }
            WritePixelArray8(rp,0,0,width-1,height-1,red,trp);
            OkFlag = !saveilbm(ilbm, rp->BitMap, pmode | HAM,
                                     width,  height, pwidth, pheight,
                                     HAM6_Palette, 16, 8,    /* colortable */
                                     mskNone, 0,    /* masking, transparent */
                                     NULL, NULL,     /* chunklists */
                                     FileName);
            // Close everything down cleanly
            FreeIFF(ilbm->ParseInfo.iff);
        }
        else {
            OkFlag = FALSE;
        }
        FreeMem(ilbm,sizeof(struct ILBMInfo));
    }
    else {
        OkFlag = FALSE;
    }
    return OkFlag;
}

/* save HAM8
 * see SaveHAM6()
 */
BOOL SaveHAM8(UBYTE *FileName,USHORT width,USHORT height, UWORD swidth,
                  USHORT pwidth, USHORT pheight, USHORT pmode,
                  UBYTE *red, UBYTE *green, UBYTE *blue, struct RastPort *rp, struct RastPort *trp) {
    UBYTE *r,*g,*b,*old,*p;
    UWORD x,y;
    ULONG maxdiff;
    ULONG diff;
    LONG t;
    UWORD k;
    UWORD index;
    BOOL OkFlag;
    struct ILBMInfo *ilbm;
    UBYTE lr,lg,lb;
    if (ilbm = (struct ILBMInfo *)AllocMem(sizeof(struct ILBMInfo),MEMF_PUBLIC|MEMF_CLEAR)) {
        if (ilbm->ParseInfo.iff = AllocIFF()) {
            r = red;
            g = green;
            b = blue;
            old = red;
            for (y=0;
                  y<height;
                  y++) {
                lr = 0;
                lg = 0;
                lb = 0;
                for (x=0;
                      x < width;
                      x++) {
                    HAM8_Palette[64*3] = *r;
                    HAM8_Palette[64*3+1] = lg;
                    HAM8_Palette[64*3+2] = lb;
                    HAM8_Palette[65*3] = lr;
                    HAM8_Palette[65*3+1] = *g;
                    HAM8_Palette[65*3+2] = lb;
                    HAM8_Palette[66*3] = lr;
                    HAM8_Palette[66*3+1] = lg;
                    HAM8_Palette[66*3+2] = *b;
                    // Find closest color
                    maxdiff = 0x7FFFFFFF;
                    p = HAM8_Palette;
                    for (k = 0;
                          k < 67;
                          ++k) {
                        t = *r - *p++;
                        diff = t*t*3;
                        t = *g - *p++;
                        diff += (t*t*6);
                        t = *b - *p++;;
                        diff += (t*t);
                        if (diff < maxdiff) {
                            maxdiff = diff;
                            index = k;
                        }
                    }
                    lr = HAM8_Palette[index*3];
                    lg = HAM8_Palette[index*3+1];
                    lb = HAM8_Palette[index*3+2];
                    if (index == 64) {
                        *old++ = (*r>>2) | 0x80;
                    }
                    else {
                        if (index == 65) {
                            *old++ = (*g>>2) | 0xc0;
                        }
                        else {
                            if (index == 66) {
                                *old++ = (*b>>2) | 0x40;
                            }
                            else {
                                *old++ = index;
                            }
                        }
                    }
                    r++;
                    g++;
                    b++;
                }
                r += (swidth - width);
                g += (swidth - width);
                b += (swidth - width);
                old += (swidth - width);
            }
            WritePixelArray8(rp,0,0,width-1,height-1,red,trp);
            OkFlag = !saveilbm(ilbm, rp->BitMap, pmode | HAM,
                                     width,  height, pwidth, pheight,
                                     HAM8_Palette, 64, 8,    /* colortable */
                                     mskNone, 0,    /* masking, transparent */
                                     NULL, NULL,     /* chunklists */
                                     FileName);
            // Close everything down cleanly
            FreeIFF(ilbm->ParseInfo.iff);
        }
        else {
            OkFlag = FALSE;
        }
        FreeMem(ilbm,sizeof(struct ILBMInfo));
    }
    else {
        OkFlag = FALSE;
    }
    return OkFlag;
}

/* save DCTV
 * see SaveBW16()
 */
BOOL SaveDCTV(UBYTE *FileName,USHORT width,USHORT height, UWORD swidth,
                  USHORT pwidth, USHORT pheight, USHORT pmode,
                  UBYTE *red, UBYTE *green, UBYTE *blue, struct RastPort *rp, struct RastPort *trp) {
    UWORD i;
    BOOL OkFlag;
    struct ILBMInfo *ilbm;
    struct DCTVCvtHandle *chandle;

    if (ilbm = (struct ILBMInfo *)AllocMem(sizeof(struct ILBMInfo),MEMF_PUBLIC|MEMF_CLEAR)) {
        if (ilbm->ParseInfo.iff = AllocIFF()) {
            // Allocate DCTV stuff
            if (chandle = AllocDCTVCvtTags(rp->BitMap,
                                            DCTVCVTA_Type, DCTVCVTT_RGBtoDCTV,
                                            DCTVCVTA_Flags,((pmode|LACE)?DCTVCVTF_Lace:0)|
                                                                DCTVCVTF_Filter|
                                                                DCTVCVTF_CustomRGBBuf,
                                            TAG_END)) {
                chandle->Red = red;
                chandle->Green = green;
                chandle->Blue = blue;
                // Convert each line
                while (chandle->DstLineNum < chandle->Height) {
                    i = chandle->SrcLineNum;
                    CvtDCTVLine(chandle);
                    if (i != chandle->SrcLineNum) {
                        chandle->Red += swidth;
                        chandle->Green += swidth;
                        chandle->Blue += swidth;
                    }
                }
                OkFlag = !saveilbm(ilbm, rp->BitMap, pmode,
                                     width,  height, pwidth, pheight,
                                     chandle->ColorTable, 1L << rp->BitMap->Depth, 4,    /* colortable */
                                     mskNone, 0,    /* masking, transparent */
                                     NULL, NULL,     /* chunklists */
                                     FileName);
                // Free DCTV stuff
                FreeDCTVCvt(chandle);
            }
            else {
                OkFlag = FALSE;
            }
            // Close everything down cleanly
            FreeIFF(ilbm->ParseInfo.iff);
        }
        else {
            OkFlag = FALSE;
        }
        FreeMem(ilbm,sizeof(struct ILBMInfo));
    }
    else {
        OkFlag = FALSE;
    }
    return OkFlag;
}